package core

import (
	"crypto/rand"
	"fmt"
	"reflect"
	"time"
)

func FormatDate(t time.Time) string {
	return t.Format("2006-01-02 15:04:05")
}
func log(ls ...interface{}) {
	for _, l := range ls {
		fmt.Println(l)
	}
}

/**
 * @retrun 返回一个唯一id字符串
 */
func uuid() string {
	b := make([]byte, 16)
	_, err := rand.Read(b)
	if err != nil {
		log(err)
	}
	uuid := fmt.Sprintf("%x%x%x%x%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:])
	return uuid
}

// 字符串bool转对bool值
func StrToBool(s string) bool {
	if s == "true" {
		return true
	} else {
		return false
	}
}

func IFString(condition bool, trueVal string, falseVal string) string {
	if condition {
		return trueVal
	}
	return falseVal
}

//将结构体source复制给dst，只复制相同名称和相同类型的
//CopyStruct(a,b)  a可以传值，引用，b只能引用，且
func CopyStruct(src, dst interface{}) interface{} {
	st := reflect.TypeOf(src)
	sv := reflect.ValueOf(src)
	dt := reflect.TypeOf(dst)
	dv := reflect.ValueOf(dst)
	if st.Kind() == reflect.Ptr { //处理指针
		st = st.Elem()
		sv = sv.Elem()
	}
	if dt.Kind() == reflect.Ptr { //处理指针
		dt = dt.Elem()
	}
	if st.Kind() != reflect.Struct || dt.Kind() != reflect.Struct { //如果不是struct类型，直接返回dst
		return dst
	}

	dv = reflect.ValueOf(dv.Interface())
	// 遍历TypeOf 类型
	for i := 0; i < dt.NumField(); i++ { //通过索引来取得它的所有字段，这里通过t.NumField来获取它多拥有的字段数量，同时来决定循环的次数
		f := dt.Field(i) //通过这个i作为它的索引，从0开始来取得它的字段

		dVal := dv.Elem().Field(i)
		sVal := sv.FieldByName(f.Name)
		//fmt.Println(dVal.CanSet())
		//src数据有效，且dst字段能赋值,类型一致
		if sVal.IsValid() && dVal.CanSet() && f.Type.Kind() == sVal.Type().Kind() {
			dVal.Set(sVal)
		}
	}
	return dst
}

func clear(v interface{}) {
	p := reflect.ValueOf(v).Elem()
	p.Set(reflect.Zero(p.Type()))
}

/*
 * 通过计算标签长度剪切字符串
 */
func getTagContent(str string, tag string) string {
	elemLength := len(tag)
	return str[elemLength+2 : len(str)-(elemLength+3)-1]
}
